package com.huohua.jobschduler.JobProcess;

import com.huohua.jobschduler.model.po.IJob;
import com.huohua.jobschduler.model.po.JobNode;

import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;

public abstract class SyncDependencyResolver extends DependencyResolver {

    // 公开方法，查找错误路径节点
    public JobNode findErrorPaths(String jobId) {
        IJob job = getJob(jobId);
        if(job == null) {
            return null;
        }
        if (job.isSuccess()) {
            return new JobNode(job);
        }
        return dfsErrorPaths(job, new LinkedHashSet<>(), new HashMap<>());
    }

    // 在抽象类中实现的深度优先搜索算法
    private JobNode dfsErrorPaths(IJob job, LinkedHashSet<String> visited, Map<String, JobNode> idToNode) {
        // 检测循环依赖
        if (job.in(visited)) {
            String[] visitedArr = visited.toArray(visited.toArray(new String[0]));
            // 将末尾到环起始点的Job都设置环标识符isRing
            int i = 0;
            for (i = visitedArr.length - 1; i >= 0; i--) {
                idToNode.get(visitedArr[i]).setIsRing(true);
                if (job.equalsJobId(visitedArr[i])) {
                    break;
                }
            }
            return new JobNode(job);
        }

        // 标记当前作业为已访问
        visited.add(job.uniqueId());

        JobNode jobNode = new JobNode(job);
        idToNode.put(job.uniqueId(), jobNode);
        if (job == null) {
            // 作业不存在，终止递归，返回 null
            // 回溯：递归完成后移除当前作业
            visited.remove(job.uniqueId());
            return null;
        }

        // 如果作业状态为 FAIL 或 UNPROCESSED，创建 JobNode
        if (job.isFail()) {
            // 回溯：递归完成后移除当前作业
            visited.remove(job.uniqueId());
            return jobNode;

        }  if (job.isUnprocessed()) {
            // 获取当前作业的前置依赖节点，继续递归查找
            List<IJob> preJobs = getPreJobs(job);  // TODO: 查询数据库获取依赖作业
            for (IJob preJob : preJobs) {
                JobNode preJobNode = dfsErrorPaths(preJob, visited, idToNode);
                if (preJobNode != null) {
                    jobNode.addPreJobNode(preJobNode);
                }
            }
            // 回溯：递归完成后移除当前作业
            visited.remove(job.uniqueId());
            return jobNode;  // 返回构建好的 JobNode
        }

        // 回溯：递归完成后移除当前作业
        visited.remove(job.uniqueId());
        return null;  // 如果作业状态正常，返回 null
    }


    // 抽象方法，由子类实现
    protected abstract IJob getJob(String jobId);


    protected abstract List<IJob> getPreJobs(IJob job);

}

